/**
 * @file command_executor_drawing.cpp
 * @brief ESP32沙画机绘图功能实现
 * 
 * 绘图功能:
 * - 开始/停止/暂停绘图
 * - 流式绘图处理
 * - 扫图功能
 * - 图案管理
 */

#include "command_executor.h"
#include "command_executor_debug.h"
#include "command_executor_performance.h"

// ==================== 优化的网络任务处理 ====================

void CommandExecutor::executeNetworkTaskOptimized() {
    static unsigned long lastNetworkCall = 0;
    static int networkCallErrors = 0;
    static bool networkTaskEnabled = true;
    
    unsigned long currentTime = millis();
    unsigned long callInterval = (networkCallErrors > 3) ? 1000 : 500;
    
    if (networkTaskEnabled && (currentTime - lastNetworkCall > callInterval)) {
        try {
            networkTaskCallback();
            lastNetworkCall = currentTime;
            networkCallErrors = 0;
        } catch (...) {
            networkCallErrors++;
            if (networkCallErrors <= 5) {  // 只在前5次错误时输出日志
                Serial.printf("⚠️ 网络任务错误 (错误计数: %d)\n", networkCallErrors);
            }
            if (networkCallErrors > 5) {
                networkTaskEnabled = false;
                Serial.println("❌ 网络任务已禁用 (连续错误过多)");
            }
        }
    }
}

// 批量状态更新函数
void CommandExecutor::updateDrawingProgress(int pointCount) {
    static unsigned long lastProgressTime = 0;
    static int lastProgressCount = 0;
    
    unsigned long currentTime = millis();
    
    // 限制状态更新频率，避免过多输出
    if (currentTime - lastProgressTime >= 5000) {  // 每5秒最多更新一次
        int pointsPerSecond = (pointCount - lastProgressCount) * 1000 / (currentTime - lastProgressTime);
        
        Serial.printf("🎯 绘图进度: %d 点 (%d 点/秒)\n", pointCount, pointsPerSecond);
        
        // 内存监控（可选）
        MEM_CHECK_THRESHOLD(30000);  // 30KB阈值
        
        lastProgressTime = currentTime;
        lastProgressCount = pointCount;
    }
}

// ==================== 绘图控制命令实现 ====================

int CommandExecutor::executeStartCommand(bool skipHoming) {
    DEBUG_PRINT("[START] 开始执行绘图命令");
    
    // 🔧 修复：统一的绘图前准备检查（包含了preExecuteCheck）
    int prepareResult = prepareForDrawing("start");
    if (prepareResult != 0) {
        Serial.printf("[ERROR] 绘图前准备检查失败，错误码: %d\n", prepareResult);
        postExecuteProcess("start", prepareResult);
        return prepareResult;
    }
    
    if (autoResumeConfig.isWaitingForResume) {
        stopAutoResumeWait();
        DEBUG_PRINT("[AUTO_RESUME] 手动启动绘图，取消自动恢复等待");
    }
    
    // 扫图暂停恢复逻辑
    if (currentContext.state == ACTIVE && currentContext.phase == PHASE_SWEEPING && *isDrawingPaused) {
        Serial.printf("🔄 扫图暂停恢复模式：从扫图索引 %d 继续扫图\n", *pausedAtIndex);
        setMaintenanceStateAndStartLED();
        
        Serial.println("🔄 恢复THR流式扫图数据 (从暂停点继续)...");
        int sweepResult = executeStreamSweepFromTHR();
        
        if (sweepResult == 0) {
            Serial.println("✅ 扫图恢复并完成");
            int loadResult = loadDefaultOrLastPattern();
            if (loadResult == 0) {
                Serial.println("✅ 图案已加载");
                setIdleStateAndEndLED(false);
                
                if (!skipHoming) {
                    int homingResult = performHomingOperation();
                    if (homingResult != 0) {
                        postExecuteProcess("start", homingResult);
                        return homingResult;
                    }
                }
                
                // 🔧 修复：明确设置绘图状态标志
                *isDrawingActive = true;
                *isDrawingPaused = false;
                
                // 调试输出
                Serial.printf("[SWEEP_RESUME] 绘图状态检查: isDrawingActive=%s, hasMorePoints=%s\n", 
                              *isDrawingActive ? "true" : "false",
                              (patternLoader && patternLoader->hasMorePoints()) ? "true" : "false");
                
                int streamResult = executeStreamDrawing();
                if (streamResult == 1) {
                    // 绘图被暂停，executeStreamDrawing已经清除了命令保护状态
                    Serial.println("[START] 绘图暂停，可接受恢复命令");
                    return 1;
                } else {
                    postExecuteProcess("start", 0);
                    return 0;
                }
            } else {
                setIdleStateAndEndLED();
                postExecuteProcess("start", loadResult);
                return loadResult;
            }
        } else if (sweepResult == 1) {
            postExecuteProcess("start", 0);
            return 0;
        } else {
            setIdleStateAndEndLED();
            postExecuteProcess("start", sweepResult);
            return sweepResult;
        }
    }
    
    // 绘图暂停恢复逻辑
    if (*isDrawingPaused && *pausedAtIndex >= 0) {
        Serial.printf("🔄 绘图暂停恢复模式：从索引 %d 继续绘图\n", *pausedAtIndex);
        
        // 🔧 修复：添加必要的预检查，但跳过命令保护检查（因为我们在处理暂停恢复）
        if (!validateSystemState()) {
            if (!*systemPowerEnabled) {
                Serial.println(GET_MSG_SYSTEM_SLEEP());
            } else {
                Serial.println("[ERROR] MotionController未初始化");
            }
            return 2;
        }
        
        // 🔧 修复：确保命令保护状态正确设置
        markCommandStart("start");
        
        *isDrawingPaused = false;
        *isDrawingActive = true;
        
        // 调试输出  
        Serial.printf("[RESUME] 绘图状态检查: isDrawingActive=%s, hasMorePoints=%s\n", 
                      *isDrawingActive ? "true" : "false",
                      (patternLoader && patternLoader->hasMorePoints()) ? "true" : "false");
        
        int streamResult = executeStreamDrawing();
        if (streamResult == 1) {
            // 绘图被暂停，executeStreamDrawing已经清除了命令保护状态
            Serial.println("[START] 绘图暂停，可接受恢复命令");
            return 1;
        } else {
            postExecuteProcess("start", 0);
            return 0;
        }
    }
    
    // 正常开始绘图
    Serial.printf("[START] 开始正常绘图流程，skipHoming=%s\n", skipHoming ? "true" : "false");
    
    if (!skipHoming) {
        Serial.println("[START] 执行归零操作...");
        int homingResult = performHomingOperation();
        if (homingResult != 0) {
            Serial.printf("[ERROR] 归零操作失败，错误码: %d\n", homingResult);
            postExecuteProcess("start", homingResult);
            return homingResult;
        }
        Serial.println("[START] 归零操作完成");
    } else {
        Serial.println("[START] 跳过归零操作（扫图已完成归零）");
    }
    
    Serial.println("[START] 开始执行流式绘图...");
    
    // 🔧 修复：明确设置绘图状态标志
    *isDrawingActive = true;
    *isDrawingPaused = false;
    
    // 调试输出
    Serial.printf("[START] 绘图状态检查: isDrawingActive=%s, hasMorePoints=%s\n", 
                  *isDrawingActive ? "true" : "false",
                  (patternLoader && patternLoader->hasMorePoints()) ? "true" : "false");
    
    int streamResult = executeStreamDrawing();
    if (streamResult == 1) {
        // 绘图被暂停，executeStreamDrawing已经清除了命令保护状态
        Serial.println("[START] 绘图暂停，可接受恢复命令");
        return 1;
    } else {
        postExecuteProcess("start", 0);
        return 0;
    }
}

int CommandExecutor::executeStopCommand() {
    Serial.println("[STOP] 执行停止命令");
    
    // 🔧 修复：添加命令互斥保护
    if (!preExecuteCheck("stop")) {
        return 1;
    }
    
    stopAutoPlay();
    stopAutoResumeWait();
    
    if (motionController) {
        motionController->stop();
    }
    
    resetDrawingStateToIdle();
    
    // 🔧 修复：使用统一的后置处理
    postExecuteProcess("stop", 0);
    return 0;
}

int CommandExecutor::executePauseCommand() {
    return executeStopCommand();
}

int CommandExecutor::executeStreamDrawing() {
    DEBUG_PRINT("[DRAW] 开始流式绘图模式");
    
    unsigned long drawingStartTime = millis();
    
    if (patternLoader) {
        int totalPoints = patternLoader->getTotalEstimatedPoints();
        // 避免不必要的String拷贝，直接使用引用
        const String& currentPattern = patternLoader->getCurrentPatternName();
        DEBUG_PRINTF("[DRAW] 图案: %s, 预估点数: %d\n", currentPattern.c_str(), totalPoints);
    }
    
    setDrawingStateAndStartLED();
    
    bool pauseRequested = false;
    bool drawingCompleted = false;
    int pointCounter = 0;
    
    while (*isDrawingActive && patternLoader && patternLoader->hasMorePoints()) {
        updateLEDOptimized();
        
        if (pauseRequested) {
            Serial.println("⏸️ 完成当前点后执行优雅暂停...");
            
            // 🔧 修复：暂停时需要设置正确的状态标志
            *isDrawingActive = false;  // 关键修复：暂停时停止绘图活动
            *isDrawingPaused = true;   // 设置暂停标志
            
            setPausedState();
            Serial.printf("⏸️ 绘图已在索引 %d 暂停\n", *pausedAtIndex);
            
            // 🔧 修复：暂停时清除命令保护状态，允许用户发送恢复命令
            markCommandEnd();
            Serial.println("🔓 清除命令保护状态，允许恢复命令");
            
            Serial.println("[STREAM] 优雅暂停完成");
            return 1; // 返回1表示暂停
        }
        
        // 批量处理网络任务（减少调用频率）
        if (networkTaskCallback && (pointCounter % PerformanceConfig::PATTERN_BATCH_SIZE == 0)) {
            executeNetworkTaskOptimized();
        }
        
        // 检查串口命令 - 使用固定缓冲区避免动态分配
        static bool isProcessing = false;
        static char inputBuffer[64];  // 固定大小缓冲区
        if (!isProcessing && Serial.available()) {
            isProcessing = true;
            
            // 读取到固定缓冲区，避免String动态分配
            size_t bytesRead = Serial.readBytesUntil('\n', inputBuffer, sizeof(inputBuffer) - 1);
            inputBuffer[bytesRead] = '\0';
            
            // 去除前后空格（简化版trim）
            char* start = inputBuffer;
            while (*start == ' ' || *start == '\t') start++;
            size_t len = strlen(start);
            while (len > 0 && (start[len-1] == ' ' || start[len-1] == '\t' || start[len-1] == '\r')) {
                start[--len] = '\0';
            }
            
            if (strcmp(start, "stop") == 0 || strcmp(start, "pause") == 0) {
                Serial.printf("🔄 绘图中接收到命令: %s\n", start);
                pauseRequested = true;
                *pausedAtIndex = patternLoader->getCurrentIndex();
            } else if (len > 0) {
                Serial.printf("⚠️ 绘图中命令被忽略: %s\n", start);
            }
            isProcessing = false;
        }
        
        // 绘制下一个点
        PatternPoint point = patternLoader->getNextPoint();
        
        if (motionController) {
            motionController->moveTo(point.theta, point.rho);
            
            while (motionController->isMovingNow() && *isDrawingActive && !pauseRequested) {
                motionController->update();
                updateLEDOptimized(false);
                
                if (Serial.available()) {
                    // 使用相同的固定缓冲区策略
                    char cmd[32];
                    size_t cmdLen = Serial.readBytesUntil('\n', cmd, sizeof(cmd) - 1);
                    cmd[cmdLen] = '\0';
                    
                    // 简化版trim和比较
                    char* trimmed = cmd;
                    while (*trimmed == ' ') trimmed++;
                    if (strncmp(trimmed, "stop", 4) == 0 || strncmp(trimmed, "pause", 5) == 0) {
                        pauseRequested = true;
                        *pausedAtIndex = patternLoader->getCurrentIndex();
                        break;
                    }
                }
                
                vTaskDelay(pdMS_TO_TICKS(1));
            }
        }
        
        pointCounter++;
        
        // 优化：减少Serial输出频率，使用批量状态更新
        if (pointCounter % 500 == 0) {  // 从100改为500，减少输出
            updateDrawingProgress(pointCounter);
        }
    }
    
    if (!pauseRequested && !patternLoader->hasMorePoints()) {
        drawingCompleted = true;
        Serial.println("✅ 绘图完成");
        
        transitionToState(STATE_IDLE, LED_COMPLETED, "绘图完成", false, false);
        
        *isDrawingActive = false;
        *isDrawingPaused = false;
        *pausedAtIndex = -1;
        
        // 记录绘图完成时间用于自动播放
        drawingCompletedTime = millis();
        if (autoPlayConfig.enabled) {
            autoPlayWaiting = true;
            recordLastCommand("draw_completed");
            Serial.printf("[AUTOPLAY] 绘图完成，%d分钟后自动播放下一个\n", 
                         autoPlayConfig.displayTimeMs / (60 * 1000));
        }
        
        setIdleStateAndEndLED();
    }
    
    unsigned long drawingDuration = millis() - drawingStartTime;
    Serial.printf("📊 绘图耗时: %lu.%03lu 秒\n", drawingDuration / 1000, drawingDuration % 1000);
    return 0; // 返回0表示正常完成
}

// ==================== 扫图功能实现 ====================

int CommandExecutor::executeSweepCommand() {
    Serial.println("[SWEEP] 执行扫图命令，整理沙盘表面");
    
    // 🔧 修复：添加命令互斥保护
    if (!preExecuteCheck("sweep")) {
        return 1;
    }
    
    if (!canExecuteMotorCommand("sweep")) {
        Serial.println("[ERROR] 系统休眠，无法执行扫图");
        postExecuteProcess("sweep", 1);
        return 1;  // 系统休眠
    }
    
    if (!motionController) {
        Serial.println("[ERROR] MotionController未初始化");
        return 2;
    }
    
    // 1. 强制归零（扫图前必须确保准确的起始位置）
    Serial.println("[HOME] 扫图前强制归零，确保精确扫图");
    Serial.println("[HOME] 开始强制归零操作...");
    
    // 🔧 统一状态管理：设置归零状态
    setHomingState();
    
    if (!motionController->homeMotorsWithCompensation()) {
        Serial.println("[ERROR] 归零失败");
        // 🔧 统一错误处理：归零失败时设置维护状态
        setMaintenanceStateOnly();
        return 2;
    }
    Serial.println("[HOME] 强制归零完成");
    
    // 🔧 统一状态管理：归零完成后只设置维护状态，LED会话将由扫图函数管理
    setMaintenanceStateOnly();
    
    // 等待归零完全稳定
    delay(1000);
    
    // 2. 使用THR文件的流式扫图数据（从外圈到圆心）
    Serial.println("[SWEEP] 使用THR文件流式扫图数据 (外圈→圆心)");
    int sweepResult = executeStreamSweepFromTHR();
    
    if (sweepResult == 1) {
        Serial.println("[PAUSE] THR扫图被暂停");
        postExecuteProcess("sweep", 1);
        return 1; // 暂停状态返回1
    } else if (sweepResult == 0) {
        Serial.println("✅ THR扫图完成");
        // 🔧 统一状态管理：扫图完成后设置空闲状态
        setIdleStateAndEndLED();
        postExecuteProcess("sweep", 0);
        return 0;
    } else {
        Serial.println("❌ THR扫图失败");
        // 🔧 统一状态管理：扫图失败时设置空闲状态
        setIdleStateAndEndLED();
        postExecuteProcess("sweep", 2);
        return 2;
    }
}

// ==================== 统一的扫图准备实现 ====================

int CommandExecutor::executeSweepAndPrepareCommand() {
    Serial.println("🧹🎯 执行完整扫图准备流程 (修复版本)");
    Serial.println("🚀 流程：强制归零 → 扫图清理 → 加载图案 → 归零 → 开始绘图");
    
    // 🔧 修复：检查是否有扫图暂停状态，如果有则恢复扫图并继续流程
    if (currentContext.state == ACTIVE && currentContext.phase == PHASE_SWEEPING && *isDrawingPaused) {
        Serial.printf("🔄 检测到扫图暂停状态，从扫图索引 %d 恢复扫图并继续完整流程\n", *pausedAtIndex);
        
        // 恢复扫图
        Serial.println("🔄 恢复THR流式扫图数据 (从暂停点继续)...");
        setMaintenanceStateOnly();
        int sweepResult = executeStreamSweepFromTHR();
        
        if (sweepResult == 1) {
            Serial.println("⏸️ 扫图再次被暂停，等待下次恢复");
            postExecuteProcess("sweepprep_real", 1);
            return 1; // 返回暂停状态
        } else if (sweepResult != 0) {
            Serial.println("❌ 扫图恢复失败");
            setIdleStateAndEndLED();
            postExecuteProcess("sweepprep_real", 2);
            return 2;
        }
        
        Serial.println("✅ 扫图恢复并完成，继续执行后续阶段...");
        
        // 执行扫图后的完整流程：重置状态 → 加载图案 → 归零 → 开始绘图
        setMaintenanceStateOnly();
        delay(100);
        
        // 加载图案
        Serial.println("🎨 阶段3: 加载图案...");
        int loadResult = loadDefaultOrLastPattern();
        
        if (loadResult != 0) {
            Serial.println("⚠️ 未找到可用图案，扫图完成但无法开始绘图");
            setIdleStateAndEndLED();
            postExecuteProcess("sweepprep_real", 0);
            return 0;
        }
        
        Serial.println("✅ 图案已加载");
        
        // 归零操作
        Serial.println("🏠 阶段4: 绘图前归零，确保精确绘图...");
        setHomingState();
        
        if (!motionController->homeMotorsWithCompensation()) {
            Serial.println("❌ 绘图前归零失败");
            setIdleStateAndEndLED();
            postExecuteProcess("sweepprep_real", 2);
            return 2;
        }
        
        Serial.println("✅ 归零完成");
        
        // 开始绘图
        Serial.println("🚀 阶段5: 开始绘图...");
        setIdleStateAndEndLED(false);
        
        *isDrawingActive = true;
        *isDrawingPaused = false;
        
        int drawResult = executeStreamDrawing();
        if (drawResult == 2) {
            Serial.println("[SWEEPPREP] 绘图暂停，可接受恢复命令");
            postExecuteProcess("sweepprep_real", 0);
            return 0;
        } else if (drawResult != 0) {
            Serial.println("❌ 绘图失败");
            postExecuteProcess("sweepprep_real", 2);
            return 2;
        }
        
        Serial.println("✅ 扫图准备和绘图全部完成！");
        postExecuteProcess("sweepprep_real", 0);
        return 0;
    }
    
    // 🔧 修复：检查是否有绘图暂停状态，如果有则直接恢复绘图
    if (*isDrawingPaused && *pausedAtIndex >= 0) {
        Serial.printf("🔄 检测到绘图暂停状态，从索引 %d 直接恢复绘图，跳过扫图流程\n", *pausedAtIndex);
        Serial.println("💡 提示：如需扫图，请先发送'stop'命令完全停止绘图，再发送'sweepprep'");
        
        // 直接调用start命令恢复绘图
        return executeStartCommand(false);  // 不跳过归零，确保精确恢复
    }
    
    // 🔧 优化：统一的前置检查
    if (!preExecuteCheck("sweepprep_real")) {
        return 1;
    }
    
    if (!canExecuteMotorCommand("sweepprep_real")) {
        Serial.println("[ERROR] 系统休眠，无法执行扫图准备");
        postExecuteProcess("sweepprep_real", 1);
        return 1;  // 系统休眠
    }
    
    if (!motionController) {
        Serial.println("❌ MotionController未初始化");
        postExecuteProcess("sweepprep_real", 2);
        return 2;
    }
    
    // 🔧 关键修复：设置扫图阶段的上下文状态
    currentContext.state = ACTIVE;
    currentContext.phase = PHASE_SWEEPING;
    currentContext.setCommand("sweepprep");
    Serial.println("🔧 已设置扫图流程上下文状态");
    
    // 🔧 统一状态管理：设置维护状态（但不启动LED会话，让各个阶段内部管理）
    setMaintenanceStateOnly();
    
    // 阶段1: 强制归零（扫图前准确定位）
    Serial.println("🏠 阶段1: 强制归零，准备扫图...");
    setHomingState();
    
    if (!motionController->homeMotorsWithCompensation()) {
        Serial.println("❌ 强制归零失败");
        setMaintenanceStateOnly();
        postExecuteProcess("sweepprep_real", 2);
        return 2;
    }
    Serial.println("✅ 强制归零完成");
    
    // 阶段2: 执行扫图清理（使用THR流式扫图数据）
    Serial.println("🧹 阶段2: 执行扫图清理...");
    setMaintenanceStateOnly();  // 准备扫图状态
    
    delay(1000);  // 等待归零完全稳定
    
    Serial.println("[SWEEP] 使用THR文件流式扫图数据 (外圈→圆心)");
    int sweepResult = executeStreamSweepFromTHR();
    
    if (sweepResult == 1) {
        // 扫图被暂停，设置正确的上下文状态以支持扫图恢复
        Serial.println("⏸️ 扫图被暂停，扫图准备流程暂停");
        
        // 🔧 关键修复：设置扫图暂停的上下文状态
        currentContext.state = ACTIVE;
        currentContext.phase = PHASE_SWEEPING;
        currentContext.setCommand("sweepprep");
        Serial.println("🔧 已设置扫图暂停上下文状态，下次sweepprep将从暂停点恢复");
        
        postExecuteProcess("sweepprep_real", 1);
        return 1; // 返回暂停状态
    } else if (sweepResult != 0) {
        Serial.println("❌ 扫图失败");
        setIdleStateAndEndLED();
        postExecuteProcess("sweepprep_real", 2);
        return 2;
    }
    
    Serial.println("✅ 阶段2: 扫图完成，继续执行后续阶段...");
    Serial.println("🔧 调试：扫图完成后的设备状态：" + String((int)deviceStateManager->getSystemState()));
    
    // 🔧 重要：重置扫图函数可能设置的状态，确保后续阶段能正常执行
    setMaintenanceStateOnly();
    Serial.println("🔧 调试：重置状态后的设备状态：" + String((int)deviceStateManager->getSystemState()));
    
    delay(100); // 给状态设置一点时间稳定
    
    // 阶段3: 加载默认图案
    Serial.println("🎨 阶段3: 加载图案...");
    Serial.println("🔧 调试：阶段3开始前的设备状态：" + String((int)deviceStateManager->getSystemState()));
    int loadResult = loadDefaultOrLastPattern();
    
    if (loadResult != 0) {
        Serial.println("⚠️ 未找到可用图案，扫图完成但无法开始绘图");
        setIdleStateAndEndLED();
        postExecuteProcess("sweepprep_real", 0);
        return 0; // 扫图成功但无图案，返回成功状态
    }
    
    Serial.println("✅ 图案已加载");
    
    // 阶段4: 再次归零（绘图前精确定位）
    Serial.println("🏠 阶段4: 绘图前归零，确保精确绘图...");
    Serial.println("🔧 调试：阶段4开始前的设备状态：" + String((int)deviceStateManager->getSystemState()));
    setHomingState();
    
    if (!motionController->homeMotorsWithCompensation()) {
        Serial.println("❌ 绘图前归零失败");
        setIdleStateAndEndLED();
        postExecuteProcess("sweepprep_real", 2);
        return 2;
    }
    Serial.println("✅ 绘图前归零完成");
    
    // 阶段5: 自动开始绘图
    Serial.println("🚀 阶段5: 自动开始绘图...");
    Serial.println("🔧 调试：阶段5开始前的设备状态：" + String((int)deviceStateManager->getSystemState()));
    setIdleStateAndEndLED();  // 恢复到空闲状态，准备绘图
    Serial.println("🔧 调试：设置空闲状态后的设备状态：" + String((int)deviceStateManager->getSystemState()));
    
    delay(100); // 给状态设置一点时间稳定
    
    Serial.println("[SWEEPPREP] 即将调用 executeStartCommand(true)...");
    
    // 🔧 修复：直接调用executeStreamDrawing，避免重复的状态检查和命令冲突
    Serial.println("[SWEEPPREP] 直接启动流式绘图，跳过重复的状态检查...");
    
    // 设置绘图状态和标志
    setDrawingStateAndStartLED();
    *isDrawingActive = true;      // 🔧 关键修复：明确设置绘图活动标志
    *isDrawingPaused = false;     // 确保暂停标志为false
    
    Serial.printf("[SWEEPPREP] 绘图状态检查: isDrawingActive=%s, hasMorePoints=%s\n", 
                  *isDrawingActive ? "true" : "false",
                  (patternLoader && patternLoader->hasMorePoints()) ? "true" : "false");
    
    // 直接调用流式绘图
    int streamResult = executeStreamDrawing();
    
    if (streamResult == 1) {
        // 绘图被暂停，executeStreamDrawing已经清除了命令保护状态
        Serial.println("[SWEEPPREP] 绘图暂停，可接受恢复命令");
        return 1;
    } else {
        Serial.println("✅ 扫图准备完整流程成功完成，绘图已开始");
        postExecuteProcess("sweepprep_real", 0);
        return 0;
    }
    
    return 0;
}

int CommandExecutor::executeSweepPrevCommand() {
    if (currentContext.state == ACTIVE && *isDrawingPaused) {
        if (currentContext.phase == PHASE_SWEEPING) {
            Serial.println("🔄 继续扫图上一个图案...");
            return executeSweepAndPrepareWithPrevPattern();
        } else if (currentContext.phase == PHASE_DRAWING) {
            Serial.println("🔄 继续绘图阶段...");
            return executeStartCommand();
        }
    }
    
    currentContext.setCommand("sweepprev");
    currentContext.setPhase(PHASE_SWEEPING);
    return executeSweepAndPrepareWithPrevPattern();
}

int CommandExecutor::executeSweepAndPrepareCore(PatternAction action) {
    String actionName = (action == KEEP_CURRENT) ? "保持当前图案" :
                       (action == SWITCH_TO_PREV) ? "切换到上一个图案" : "切换到下一个图案";
    Serial.println("🧹🎯 执行扫图准备核心流程: " + actionName);
    Serial.println("🚀 流程：强制归零 → 扫图清理 → 图案操作 → 归零 → 开始绘图");
    
    // 🔧 修复：检查绘图暂停状态
    if (*isDrawingPaused && *pausedAtIndex >= 0) {
        if (action == KEEP_CURRENT) {
            Serial.printf("🔄 检测到绘图暂停状态，保持当前图案，从索引 %d 直接恢复绘图\n", *pausedAtIndex);
            Serial.println("💡 提示：如需扫图，请先发送'stop'命令完全停止绘图");
            return executeStartCommand(false);
        } else {
            Serial.printf("🔄 检测到绘图暂停状态，需要%s，将先完全停止当前绘图再执行扫图流程\n", actionName.c_str());
            // 先完全停止绘图，清除暂停状态
            *isDrawingActive = false;
            *isDrawingPaused = false;
            *pausedAtIndex = -1;
            Serial.println("🔄 已清除绘图暂停状态，继续执行扫图流程");
        }
    }
    
    // 🔧 优化：统一的前置检查
    if (!preExecuteCheck("sweepprep_core")) {
        return 1;
    }
    
    if (!canExecuteMotorCommand("sweepprep_core")) {
        Serial.println("[ERROR] 系统休眠，无法执行扫图准备");
        postExecuteProcess("sweepprep_core", 1);
        return 1;  // 系统休眠
    }
    
    if (!motionController) {
        Serial.println("❌ MotionController未初始化");
        postExecuteProcess("sweepprep_core", 2);
        return 2;
    }
    
    // 🔧 统一状态管理：设置维护状态（但不启动LED会话，让各个阶段内部管理）
    setMaintenanceStateOnly();
    
    // 阶段1: 强制归零（扫图前准确定位）
    Serial.println("🏠 阶段1: 强制归零，准备扫图...");
    setHomingState();
    
    if (!motionController->homeMotorsWithCompensation()) {
        Serial.println("❌ 强制归零失败");
        setMaintenanceStateOnly();
        postExecuteProcess("sweepprep_core", 2);
        return 2;
    }
    Serial.println("✅ 强制归零完成");
    
    // 阶段2: 执行扫图清理（使用THR流式扫图数据）
    Serial.println("🧹 阶段2: 执行扫图清理...");
    setMaintenanceStateOnly();  // 准备扫图状态
    
    delay(1000);  // 等待归零完全稳定
    
    Serial.println("[SWEEP] 使用THR文件流式扫图数据 (外圈→圆心)");
    int sweepResult = executeStreamSweepFromTHR();
    
    if (sweepResult == 1) {
        // 扫图被暂停，设置正确的上下文状态以支持扫图恢复
        Serial.println("⏸️ 扫图被暂停，扫图准备流程暂停");
        
        // 🔧 关键修复：设置扫图暂停的上下文状态
        currentContext.state = ACTIVE;
        currentContext.phase = PHASE_SWEEPING;
        currentContext.setCommand("sweepprep_core");
        Serial.println("🔧 已设置扫图暂停上下文状态，下次sweepprep将从暂停点恢复");
        
        postExecuteProcess("sweepprep_core", 1);
        return 1; // 返回暂停状态
    } else if (sweepResult != 0) {
        Serial.println("❌ 扫图失败");
        setIdleStateAndEndLED();
        postExecuteProcess("sweepprep_core", 2);
        return 2;
    }
    
    Serial.println("✅ 阶段2: 扫图完成，继续执行后续阶段...");
    
    // 🔧 重要：重置扫图函数可能设置的状态，确保后续阶段能正常执行
    setMaintenanceStateOnly();
    delay(100); // 给状态设置一点时间稳定
    
    // 阶段3: 根据action执行图案操作
    Serial.println("🎨 阶段3: " + actionName + "...");
    int loadResult = 0;
    
    // 根据action执行不同的图案操作
    switch (action) {
        case KEEP_CURRENT:
            // 尝试加载最后使用的图案或默认图案
            loadResult = loadDefaultOrLastPattern();
            break;
            
        case SWITCH_TO_PREV:
            // 尝试加载上一个图案
            loadResult = loadPreviousPattern();
            break;
            
        case SWITCH_TO_NEXT:
            // 尝试加载下一个图案
            loadResult = loadNextPattern();
            break;
            
        default:
            Serial.println("❌ 未知的图案操作类型");
            loadResult = 2;
            break;
    }
    
    if (loadResult != 0) {
        Serial.println("⚠️ 未找到可用图案，扫图完成但无法开始绘图");
        setIdleStateAndEndLED();
        postExecuteProcess("sweepprep_core", loadResult);
        return loadResult;
    }
    
    Serial.println("✅ 图案已加载");
    
    // 阶段4: 再次归零（绘图前精确定位）
    Serial.println("🏠 阶段4: 绘图前归零，确保精确绘图...");
    setHomingState();
    
    if (!motionController->homeMotorsWithCompensation()) {
        Serial.println("❌ 绘图前归零失败");
        setIdleStateAndEndLED();
        postExecuteProcess("sweepprep_core", 2);
        return 2;
    }
    Serial.println("✅ 绘图前归零完成");
    
    // 阶段5: 自动开始绘图
    Serial.println("🚀 阶段5: 自动开始绘图...");
    setIdleStateAndEndLED();  // 恢复到空闲状态，准备绘图
    delay(100); // 给状态设置一点时间稳定
    
    Serial.println("[SWEEPPREP_CORE] 直接启动流式绘图...");
    
    // 设置绘图状态和标志
    setDrawingStateAndStartLED();
    *isDrawingActive = true;      // 🔧 关键修复：明确设置绘图活动标志
    *isDrawingPaused = false;     // 确保暂停标志为false
    
    Serial.printf("[SWEEPPREP_CORE] 绘图状态检查: isDrawingActive=%s, hasMorePoints=%s\n", 
                  *isDrawingActive ? "true" : "false",
                  (patternLoader && patternLoader->hasMorePoints()) ? "true" : "false");
    
    // 直接调用流式绘图
    int streamResult = executeStreamDrawing();
    
    if (streamResult == 1) {
        // 绘图被暂停，executeStreamDrawing已经清除了命令保护状态
        Serial.println("[SWEEPPREP_CORE] 绘图暂停，可接受恢复命令");
        return 1;
    } else {
        Serial.println("✅ 扫图准备核心流程成功完成，绘图已开始");
        postExecuteProcess("sweepprep_core", 0);
        return 0;
    }
}

int CommandExecutor::executeSweepAndPrepareWithPrevPattern() {
    return executeSweepAndPrepareCore(SWITCH_TO_PREV);
}

int CommandExecutor::executeSweepAndPrepareWithNextPattern() {
    return executeSweepAndPrepareCore(SWITCH_TO_NEXT);
}


int CommandExecutor::executeSweepNextCommand() {
    if (currentContext.state == ACTIVE && *isDrawingPaused) {
        if (currentContext.phase == PHASE_SWEEPING) {
            Serial.println("🔄 继续扫图下一个图案...");
            return executeSweepAndPrepareWithNextPattern();
        } else if (currentContext.phase == PHASE_DRAWING) {
            Serial.println("🔄 继续绘图阶段...");
            return executeStartCommand();
        }
    }
    
    currentContext.setCommand("sweepnext");
    currentContext.setPhase(PHASE_SWEEPING);
    return executeSweepAndPrepareWithNextPattern();
}

// ==================== 辅助函数实现 ====================

void CommandExecutor::resetDrawingStateToIdle() {
    *isDrawingActive = false;
    *isDrawingPaused = false;
    *pausedAtIndex = -1;
    setIdleStateAndEndLED();
    Serial.println("[STATE] 绘图状态已重置为空闲");
}

int CommandExecutor::validateAndLoadPattern() {
    // 🔧 修复：支持流式模式的图案验证
    bool hasValidPattern = false;
    if (patternLoader->isInStreamMode()) {
        hasValidPattern = patternLoader->hasMorePoints();
        Serial.printf("[VALIDATE] 流式模式验证: hasMorePoints=%s\n", hasValidPattern ? "true" : "false");
    } else {
        hasValidPattern = (patternLoader->getPatternSize() > 0);
        Serial.printf("[VALIDATE] 传统模式验证: size=%d\n", patternLoader->getPatternSize());
    }
    
    if (!hasValidPattern) {
        Serial.println("[ERROR] 没有有效的图案数据");
        return 2;
    }
    return 0;
}

int CommandExecutor::performHomingOperation() {
    if (!motionController) {
        Serial.println("[ERROR] 运动控制器未初始化");
        return 1;
    }
    
    setHomingState();
    Serial.println("[HOMING] 开始归零操作...");
    
    bool homingSuccess = motionController->homeMotorsWithCompensation();
    
    if (homingSuccess) {
        Serial.println("[HOMING] 归零操作完成");
        setIdleStateAndEndLED();
        return 0;
    } else {
        Serial.println("[ERROR] 归零操作失败");
        setEmergencyState("归零失败");
        return 1;
    }
}

void CommandExecutor::updateLEDOptimized(bool forceUpdate) {
    if (ledControlCenter) {
        ledControlCenter->update();
    }
}
